home *** CD-ROM | disk | FTP | other *** search
/ Skunkware 5 / Skunkware 5.iso / src / Games / dinkum3 / taker.c < prev   
Encoding:
C/C++ Source or Header  |  1995-05-03  |  34.5 KB  |  1,327 lines
  1. #define TAKER
  2. #include "dink_sym.h"
  3. #include "dink_glb.h"
  4.  
  5. #if (PROTOTYPE)
  6. void taker(int n)
  7. #else
  8. taker(n)
  9. int n ;
  10. #endif
  11. /*********************************************************/
  12. /*                                                       */
  13. /*           --- Object Taking Subroutine ---            */
  14. /*                                                       */
  15. /*      Program by Gary A. Allen, Jr.   15 January 1993  */
  16. /*        (c) Copyright 1993 by Gary A. Allen, Jr.       */
  17. /*                                                       */
  18. /*********************************************************/
  19. {
  20. register int i, j ;
  21. int  sw_done, gleep_local, ammo_flag ;
  22. OBJECT_STRUCT *pnt ;
  23.  
  24. #if (PROTOTYPE)
  25. void clip_in(int), clip_out(int), ender(int), eater(void) ;
  26. #endif
  27.  
  28. /* Alias in the object for the single word "take" command */
  29. if (tag[V_VERB_ONLY]) {
  30.     j = 0 ;
  31.     /* See if there is only one object on the floor */
  32.     pnt = object ;
  33.     for (i = 0; i < Objcnt; i++) {
  34.         if (n == pnt->Location) {
  35.             j++ ;
  36.             tag[pnt->ID] = TRUE ;
  37.         }
  38.         pnt++ ;
  39.     }
  40.  
  41.     if (room[n][M_gleep] != 0) {
  42.         j++ ;
  43.         tag[V_gleep] = TRUE ;
  44.         if (room[n][M_gleep] > 1) tag[V_PLURAL] = TRUE ;
  45.     }
  46.  
  47.     /* Complain if there isn't a single object on the ground */
  48.     if (j > 1) {
  49.         printf ("What exactly do you want me to take? \n");
  50.         return ;
  51.     }
  52. }
  53.  
  54. ammo_flag = F_no_clip ;
  55. if (tag[V_clip]) ammo_flag = F_normal_clip ;
  56. if (tag[V_org_clip]) ammo_flag = F_org_clip ;
  57.  
  58. /* deal with special case of "orange clip" implied by its being alone */
  59. if (tag[V_clip]&&(Clip->Location != n)&&(Org_clip->Location == n)) {
  60.     tag[V_org_clip] = TRUE ;
  61.     tag[V_clip] = FALSE ;
  62.     if (V_clip == sent[1]) sent[1] = V_org_clip ;
  63. }
  64.  
  65. /* deal with the verb "attach" */
  66. if (verb == V_attach) {
  67.     if (tag[V_rifle]&&(ammo_flag != F_no_clip)) {
  68.         clip_in(ammo_flag) ;
  69.         return ;
  70.     }
  71.     if ((n != R_office_mang)&&(room[n][M_obj_cnt] <= 0)) {
  72.         printf ("There is nothing here that I can attach!\n");
  73.         return ;
  74.     }
  75. }
  76.  
  77. /* Check to see if player already has the item */
  78. pnt = object ;
  79. for (i = 0; i < Objcnt; i++) { 
  80.     if (pnt->ID == sent[1]) {
  81.         if (pnt->Location == B_have) {
  82. printf ("You already have a %s in your possession.\n",vocab[sent[1]-1]);
  83.             return ;
  84.         }
  85.         else break ;
  86.     }
  87.     pnt++ ;
  88. }
  89.  
  90. sw_done = FALSE ;
  91.  
  92. /* Special case of "take pill" */
  93. if ((tag[V_pill])&&(Pills->Location == B_have)) {
  94.     eater() ;
  95.     return ;
  96. }
  97.  
  98. /* Reject "take" command when there is nothing to take */
  99. if ((n != R_office_mang)&&(verb != V_attach)&&(verb != V_remove)&&
  100.     (room[n][M_obj_cnt] <= 0)&&(room[n][M_gleep] == 0)&&
  101.     (!((n == R_gleep_tank)&&(Tank->Status > 0)))
  102.     &&(!room[n][M_unmov_obj])) {
  103.     printf ("There is nothing here that you can take! \n");
  104.     return ;
  105. }
  106.  
  107. /* player takes something from the gleep tank */
  108. if (tag[V_tank]) {
  109.     if (n != R_gleep_tank) {
  110. printf("I see no gleep tank to take anything from. \n") ;
  111.         return ;
  112.     }
  113. printf("\nYou climb up onto the edge of the gleep tank and reach\n");
  114. printf("into the dark blue fluid.  Suddenly the fluid begins a\n");
  115. printf("furious boiling that instantly reduces your hand into\n") ;
  116. printf("bleached white bones.  The shock and pain disturbs your\n");
  117. printf("balance and you fall into the horrible stuff!!  There is\n");
  118. printf("once again a furious boiling.  Eventually the fluid stills\n");
  119. printf("and becomes clear again.  On the bottom of the tank can\n") ;
  120. printf("be seen a white, clean, \"medical school quality\" human\n");
  121. printf("skeleton.\n") ;
  122.     ender(F_died) ;
  123. }
  124.  
  125. /* Deal with "safe" taking errors */
  126. if ((tag[V_safe])&&(n != R_office_mang)) {
  127.     printf("There is no safe here.\n") ;
  128.     return ;
  129. }
  130.  
  131. /* gleep taking routine (must be after the gleep tank routine) */
  132. if (tag[V_gleep]) {
  133. if (!tag[V_safe]) {
  134.  
  135.     /* Count up the gleeps available in this room */
  136.     if ((n == R_office_mang)&&(Safe->Status == S_open)) 
  137.         gleep_local = gleep_safe ;
  138.     else gleep_local = 0 ;
  139.     gleep_local += room[n][M_gleep] ;
  140.     /* Gleeps in the tank aren't really accessible but the player */
  141.     /*    may wish to suicide by taking them.                     */
  142.     if (n == R_gleep_tank) gleep_local += Tank->Status ;
  143.  
  144.     /* Leave if there are no gleeps */
  145.     if (gleep_local == 0) {
  146.         printf("There are no gleeps here to take!\n") ;
  147.         return ;
  148.     }
  149.  
  150.     /* Gleeps in the tank but not on the floor */
  151.     /*   This is to lure player into suicide.  */
  152.     if ((n == R_gleep_tank)&&(room[n][M_gleep] == 0)) {
  153.         printf("There are no gleeps on the floor but I see ") ;
  154.         if (Tank->Status == 1) 
  155.             printf("a gleep in the gleep tank.\n");
  156.         else
  157.             printf("%d gleeps in the gleep tank.\n",Tank->Status) ;
  158.         return ;
  159.     }
  160.  
  161.     /* This block is for accessible gleeps in office with open safe */
  162.     if ((n == R_office_mang)&&(Safe->Status == S_open)
  163.             &&(Picture->Status == S_open)) {
  164.         if ((!tag[V_PLURAL])||(gleep_local == 1)) {
  165.             printf("Gleep taken. \n") ; 
  166.             ++gleep_count ;
  167.             if (gleep_safe == 0) --room[n][M_gleep] ;
  168.             else --gleep_safe ;
  169.         }
  170.         else {
  171.             if (tag[V_NUMBER]) {
  172.                 if (number_word == 0) {
  173.                     printf("Don't be silly.\n") ;
  174.                     return ;
  175.                 }
  176.                 if (number_word > gleep_local) {
  177. printf("There aren't that many gleeps here!\n") ;
  178.                     return ;
  179.                 }
  180.                 else {
  181. printf("%d gleeps taken.\n", number_word) ; 
  182.                     gleep_count += number_word ;
  183.                     gleep_local -= number_word ;
  184.                     gleep_safe = gleep_local ;
  185.                     room[n][M_gleep] = 0 ;
  186.                 }
  187.             }
  188.             else {
  189.                 printf("Gleeps taken. \n") ; 
  190.                 gleep_count += gleep_local ;
  191.                 room[n][M_gleep] = 0 ;
  192.                 gleep_safe = 0 ;
  193.             }
  194.         }
  195.         return ;
  196.     }
  197.  
  198.     /* This block is for accessible gleeps everywhere else */
  199.     /*       or the office with the safe closed.           */
  200.     if ((!tag[V_PLURAL])||(room[n][M_gleep] == 1)) {
  201.         printf("Gleep taken. \n") ; 
  202.         ++gleep_count ;
  203.         --room[n][M_gleep] ;
  204.     }
  205.     else {
  206.         if (tag[V_NUMBER]) {
  207.             if (number_word == 0) {
  208.                 printf("Don't be silly.\n") ;
  209.                 return ;
  210.             }
  211.             if (number_word > room[n][M_gleep]) {
  212. printf("There aren't that many gleeps here!\n") ;
  213.                     return ;
  214.             }
  215.             else {
  216.                 printf("%d gleeps taken.\n", number_word) ; 
  217.                 gleep_count += number_word ;
  218.                 room[n][M_gleep] -= number_word ;
  219.             }
  220.         }
  221.         else {
  222.             printf("Gleeps taken. \n") ; 
  223.             gleep_count += room[n][M_gleep] ;
  224.             room[n][M_gleep] = 0 ;
  225.         }
  226.     }
  227.     return ;
  228. } /* sentence does NOT have the word "safe" block */
  229. else {
  230.     if ((Picture->Status == S_open)&&(Safe->Status == S_open)) {
  231.         if (gleep_safe != 0) { 
  232.         if (tag[V_PLURAL] && (gleep_safe > 1)) {
  233.             if (tag[V_NUMBER]) {
  234.                 if (number_word == 0) {
  235.                     printf("Don't be silly.\n") ;
  236.                     return ;
  237.                 }
  238.                 if (number_word > gleep_safe) {
  239. printf("There aren't that many gleeps in the safe!\n") ;
  240.                     return ;
  241.                 }
  242.                 else {
  243. printf("%d gleeps taken.\n", number_word) ; 
  244.                     gleep_count += number_word ;
  245.                     gleep_safe -= number_word ;
  246.                 }
  247.             }
  248.             else {
  249.                 printf("Gleeps taken from safe. \n") ; 
  250.                 gleep_count += gleep_safe ;
  251.                 gleep_safe = 0 ;
  252.             }
  253.         }
  254.         else {
  255.             printf("Gleep taken from safe. \n") ; 
  256.             ++gleep_count ;
  257.             --gleep_safe ;
  258.         }
  259.         }
  260.         else printf("There are no gleeps in the safe!\n") ;
  261.     }
  262.     else {
  263.         if (tag[V_PLURAL]) 
  264. printf("There is no open safe to take gleeps from.\n") ;
  265.         else
  266. printf("There is no open safe to take the gleep from.\n") ;
  267.     }
  268.     return ;
  269. } /* sentence does have the word "safe" block */
  270. } /* end of the gleep taking block */
  271.  
  272.  
  273. /* treat the verb "remove" in the context of "remove clip from rifle" */
  274. if (verb == V_remove) {
  275.     if ((!tag[V_safe])&&(ammo_flag != F_no_clip)) {
  276.         clip_out(n) ;
  277.         return ;
  278.     }
  279. }
  280.  
  281. if (carry_count > 5) {
  282. printf("I can't do it!\n") ;
  283. printf("I'm holding so many things that I can't take anymore!\n") ;
  284.     return ;
  285. }
  286.  
  287. if (carry_weight >= 800) {
  288. printf("I can't do it!\n") ;
  289. printf("This junk I'm carrying is too heavy! I can't carry anymore!\n");
  290.     return ;
  291. }
  292.  
  293.  
  294. /* find the object(s) in this room */
  295. pnt = object ;
  296. for (i = 0; i < Objcnt; i++) {
  297.  
  298.     if ((carry_count > 5)||(carry_weight >= 800)) break ;
  299.  
  300.     /* See if the object is in the safe and was requested */
  301.     if ((n == R_office_mang)&&(pnt->Location == B_in_safe)
  302.         &&(tag[pnt->ID]||tag[V_all])
  303.         &&((!tag[V_treasure])||(pnt->Value > 0))) {
  304.  
  305.         if (Picture->Status != S_open) {
  306.             if (tag[V_all] || tag[V_treasure])
  307.                 printf("I don't see a safe.\n") ;
  308.             else printf("You need to open the picture first.\n") ;
  309.             return ;
  310.         }
  311.         if (Safe->Status == S_open) {
  312.             pnt->Location = B_have; 
  313.             carry_count++ ;
  314.             carry_weight += pnt->Weight ; 
  315.             sw_done = TRUE ;
  316.         }
  317.         else {
  318.             printf("I can't do it because the safe is closed. \n") ;
  319.             return ;
  320.         }
  321.     } 
  322.     
  323.     /* See if the object is in the room and was requested */
  324.     if ((pnt->Location == n)&&(tag[pnt->ID] || tag[V_all])
  325.         &&((!tag[V_treasure])||(pnt->Value > 0))) {
  326.  
  327.         /* Objects referred to in this block are not in the safe */
  328.         if (!tag[V_safe]) {
  329.         /* see if taking the object causes special action */
  330.         if (pnt->Type == Z_transform) {
  331.             switch(pnt->ID) {
  332.             /* ACME doormat */
  333.             case V_mat:
  334. printf("As you lift up the dirty old doormat, you find half \n") ;
  335. printf("hidden in the dust....  a large brass key. \n") ;
  336.                 Mat->Type = Z_normal ;
  337.                 carry_count++ ;
  338.                 carry_weight += Mat->Weight;
  339.                 Mat->Location = B_have;
  340.                 Key->Location = R_office_entr ;
  341.                 sw_done = TRUE ;
  342.                 return ;
  343.  
  344.             /* Map of the ACME Mine */
  345.             case V_map:
  346. printf("As you picked up the old map from the floor, most of it");
  347. printf(" crumbled into \ndust leaving only one small piece. \n") ;
  348.                 Map->Location = B_unmade ;
  349.                 Map_frag->Location = B_have ;
  350.                 carry_count++ ;
  351.                 carry_weight += Map_frag->Weight ;
  352.                 --room[n][M_obj_cnt] ;
  353.                 sw_done = TRUE ;
  354.                 return ;
  355.             }
  356.         } /* end of the special action block */ 
  357.  
  358.         /* see if an object on the floor can be taken */
  359.         if ((pnt->Type == Z_normal)||
  360.                 (pnt->Type == Z_alias)) {
  361.             --room[n][M_obj_cnt] ;
  362.             carry_count++ ;
  363.             carry_weight += pnt->Weight ; 
  364.             pnt->Location = B_have; 
  365.             sw_done = TRUE ;
  366.         } 
  367.         }
  368.  
  369.         /* see if this is an unmovable, nonacting object */
  370.         if ((pnt->Type == Z_unmovable) &&
  371.                 (pnt->Location == n) && (!tag[V_all])) {
  372.  
  373.             switch(pnt->ID) {
  374.             case V_bulldust:
  375. printf("The bulldust is so fine that it wafts away with a touch.\n") ;
  376.                 return ;
  377.  
  378.             /* Silver gong */
  379.             case V_gong:
  380. printf("The siver gong is about three metres in diameter and weighs at\n") ;
  381. printf("least a ton!  There is no way I could move it, let alone get\n") ;
  382. printf("it through the tunnel!\n") ;
  383.                 return ;
  384.  
  385.             /* Cockroach(es) */
  386.             case V_cockroach:
  387. printf("I will not touch the filthy things!\n") ;
  388.                 return ;
  389.  
  390.             /* Kangaroo(s) */
  391.             case V_kangaroo:
  392. printf("I will not touch a dead maggoty kangaroo!  ") ;
  393. printf("The smell is bad enough!\n") ;
  394.                 return ;
  395.  
  396.             case V_desk:
  397. printf("The desk is of very solid construction and can not be moved.\n") ;
  398.                 return ;
  399.  
  400.             case V_chart:
  401. printf("The charts and production schedules are so old and brittle that\n") ;
  402. printf("they'd fall apart the moment you touched them.  Besides they're\n") ;
  403. printf("useless and not worth taking.\n") ;
  404.                 return ;
  405.  
  406.             case V_poster:
  407. printf("I think this sort of poster is best left on the wall.\n") ;
  408.                 return ;
  409.  
  410.             /* Spinifex(es) */
  411.             case V_spinifex:
  412. printf("The thorns on the spinifex are large and nasty.\n") ;
  413. printf("I'll just leave them to roll about.\n") ;
  414.                 return ;
  415.  
  416.             /* Platypus Picture */
  417.             case V_picture:
  418. printf("The picture can not be removed.  It appears to be hinged ");
  419. printf("to the wall.\n");
  420.                 return ;
  421.  
  422.             /* Safe */
  423.             case V_safe:
  424.                 if (sw_done) break ;
  425. printf("The safe is set in a concrete wall.  I can see no way\n") ;
  426. printf("the safe can be removed without destroying the wall.\n") ;
  427.                 return ;
  428.  
  429.             /* Building door */
  430.             case V_door:
  431.                 if (Door->Status == S_kicked) 
  432. printf("The door is too heavy and bulky to move.\n") ;
  433.                 else {
  434. printf("The door is attached to the building with some heavy duty\n") ;
  435. printf("hinges which I can't remove.\n") ;
  436.                 }
  437.                 return ;
  438.  
  439.             /* "Other" non-movable objects */
  440.             default:
  441.                 printf("I don't think I can move that.\n") ;
  442.                 return ;
  443.             } /* end of switch block */
  444.         } /* end of unmovable object block */ 
  445.  
  446.     } 
  447.     pnt++ ;
  448. } /* end of the object scan loop */
  449.  
  450. /* take all gleeps if any */
  451. if (tag[V_all]&&(!tag[V_treasure])) {
  452.     if (room[n][M_gleep] > 0) { 
  453.         gleep_count += room[n][M_gleep] ;
  454.         room[n][M_gleep] = 0 ;
  455.         sw_done = TRUE ;
  456.     }
  457.     if ((gleep_safe != 0)&&(n == R_office_mang)
  458.             &&(Safe->Status == S_open)) {
  459.         gleep_count +=  gleep_safe ;
  460.         gleep_safe = 0 ;
  461.         sw_done = TRUE ;
  462.     }
  463. }
  464.  
  465. /* Announce the "take" was successful */
  466. if (sw_done) {
  467.     if (((carry_count > 5)||(carry_weight >= 800))&&(tag[V_all])) 
  468.         printf("You've taken as much as you can.\n") ;
  469.     else printf ("Done \n");
  470. }
  471. /* --else-- announce the "take" was unsuccessful */
  472. else  {
  473.     if (tag[V_all]) printf("I see nothing which I can take.\n") ;
  474.     else { 
  475.         if (tag[V_VERB_ONLY]) 
  476.             printf("What exactly should I take?\n") ;
  477.         else {
  478.             printf ("I don't see a") ;
  479.             if (tag[V_PLURAL]) printf("ny") ;
  480.             printf (" %s around here. \n",vocab[sent[1]-1]);
  481.         }
  482.     }
  483. }
  484. return ;
  485.  
  486. } /* --- end of the "taker" subroutine --- */
  487.  
  488. #if (PROTOTYPE)
  489. void loader(void)
  490. #else
  491. loader()
  492. #endif
  493. /*********************************************************/
  494. /*                                                       */
  495. /*           --- Rifle Loading Subroutine ---            */
  496. /*                                                       */
  497. /*      Program by Gary A. Allen, Jr.  29 April 1990     */
  498. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  499. /*                                                       */
  500. /*********************************************************/
  501. {
  502.  
  503. int ammo_flag ;
  504.  
  505. #if (PROTOTYPE)
  506. void clip_in(int) ;
  507. #endif
  508.  
  509. /* Reject single verb load command */
  510. if (tag[V_VERB_ONLY]) {
  511. printf("What exactly do you want me to load?\n") ;
  512.     return ;
  513. }
  514. if (!tag[V_rifle]) {
  515. printf("I don't know how I could load that.\n") ;
  516.     return ;
  517. }
  518.  
  519. /* Deal with implied clip type command */
  520. if (!tag[V_clip]) {
  521.     if ((Clip->Location != B_have)&&
  522.         (Org_clip->Location == B_have)) ammo_flag = F_org_clip ;
  523.  
  524.     /* the case were there is no clip is found in clip_in */
  525.     if ((Clip->Location == B_have)&&
  526.          (Org_clip->Location != B_have)) ammo_flag = F_normal_clip ;
  527. }
  528.  
  529. /* Deal with specific "load [orange] clip" command */
  530. else {
  531.     if (tag[V_orange]) {
  532.         if (Org_clip->Location == B_have) ammo_flag = F_org_clip ;
  533.         else {
  534. printf("You don't possess the orange ammunition clip.\n") ;
  535.             return ;
  536.         }
  537.     }
  538.     else {
  539.         if (Clip->Location == B_have) ammo_flag = F_normal_clip ;
  540.  
  541.         /* Assume "load clip" with no normal clip implies orange clip */
  542.         else {
  543.             if (Org_clip->Location == B_have) 
  544.                 ammo_flag = F_org_clip ;
  545.             else{
  546. printf("You don't possess an ammunition clip to load.\n") ;
  547.                 return ;
  548.             }
  549.         }
  550.     }
  551. }
  552.  
  553. clip_in(ammo_flag) ;
  554. } /* --- end of the "loader" subroutine --- */
  555.  
  556. #if (PROTOTYPE)
  557. void unloader(int n)
  558. #else
  559. unloader(n)
  560. int n ;
  561. #endif
  562. /*********************************************************/
  563. /*                                                       */
  564. /*          --- Rifle Unloading Subroutine ---           */
  565. /*                                                       */
  566. /*      Program by Gary A. Allen, Jr.  29 April 1990     */
  567. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  568. /*                                                       */
  569. /*********************************************************/
  570. {
  571. #if (PROTOTYPE)
  572. void clip_out(int) ;
  573. #endif
  574.  
  575. /* Reject single verb load command */
  576. if (tag[V_VERB_ONLY]) {
  577. printf("What exactly do you want me to unload?\n") ;
  578.     return ;
  579. }
  580. if (!tag[V_rifle]) {
  581. printf("I don't know how I could unload that.\n") ;
  582.     return ;
  583. }
  584. clip_out(n) ;
  585. } /* --- end of the "unloader" subroutine --- */
  586.  
  587. #if (PROTOTYPE)
  588. void dropper(int n)
  589. #else
  590. dropper(n)
  591. int n ;
  592. #endif
  593. /*********************************************************/
  594. /*                                                       */
  595. /*          --- Object Dropping Subroutine ---           */
  596. /*                                                       */
  597. /*      Program by Gary A. Allen, Jr.  21 May 1990       */
  598. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  599. /*                                                       */
  600. /*********************************************************/
  601. {
  602. register int i, k ;
  603.  
  604. int sw_possess, sw_done, ammo_flag, sw_object, i_10, i_fract ;
  605. int sw_found ;
  606.  
  607. OBJECT_STRUCT *pnt ;
  608.  
  609. #if (PROTOTYPE)
  610. void clip_in(int), clip_out(int), boom(void) ;
  611. void objlooker(int), gleeper(int), unlocker(int) ;
  612. void cap_drop(void), dynamite_drop(void), destroy_all(void) ;
  613. void dropped_gun(void) ;
  614. #endif
  615.  
  616. /* respond to "verb only" command */
  617. if (tag[V_VERB_ONLY]) {
  618.     printf ("You'll have to be more specific. \n");
  619.     return ;
  620. }
  621.  
  622. /* deal with special case of "orange clip" implied by its being alone */
  623. if (tag[V_clip]&&(Clip->Location != B_have)
  624.         &&(clip_flag != F_normal_clip)
  625.         &&((Org_clip->Location == B_have)||(clip_flag == F_org_clip))) {
  626.     tag[V_org_clip] = TRUE ;
  627.     tag[V_clip] = FALSE ;
  628.     if (V_clip == sent[1]) sent[1] = V_org_clip ;
  629. }
  630.  
  631. ammo_flag = F_no_clip ;
  632. if (tag[V_clip])  ammo_flag = F_normal_clip ;
  633. if (tag[V_org_clip])  ammo_flag = F_org_clip ;
  634.  
  635. /* deal with special cases of the verbs */
  636. switch(verb) {
  637. case V_put:
  638.     /* special case of putting (destroying) an object in water */
  639.     if (tag[V_tank]||tag[V_gleep]||tag[V_safe]||
  640.         tag[V_river]||tag[V_billabong]||tag[V_stream]) break ;
  641.  
  642.     /* special case of "put key in door(lock)" */
  643.     if (tag[V_key] && tag[V_door]) {
  644.         unlocker(n) ;
  645.         return ;
  646.     }
  647.  
  648.     if (!tag[V_cap]) {
  649.         if ((!tag[V_rifle])&&(ammo_flag != F_no_clip)) {
  650.             printf("What am I to put the clip into? \n") ;
  651.             return ;
  652.         }
  653.         if (tag[V_rifle]&&(ammo_flag != F_no_clip))  
  654.                 clip_in(ammo_flag) ;
  655.         else 
  656. printf("I don't understand what this is to be put into. \n") ;
  657.         return ;
  658.     }
  659.  
  660. case V_insert:
  661.     if (tag[V_safe]) break ;
  662.     if (ammo_flag != F_no_clip) {
  663.         if (!tag[V_rifle]) {
  664. printf("What am I to insert the clip into? \n") ;
  665.         }
  666.         else {
  667.             clip_in(ammo_flag) ;
  668.         }
  669.         return ;
  670.     }
  671.     if (tag[V_cap]) {
  672.         if (!tag[V_dynamite]) {
  673. printf("I see no reason why I should put a blasting cap into that.\n") ;
  674.             return ;
  675.         }
  676.         /* Cap insertion routine */
  677.         else {
  678.             /* see if your are holding the dynamite or the cap */
  679.             if ((Cap->Location != B_have)&&
  680.                 (Dynamite->Location != B_have)) {
  681. printf("You bloody dill!  You have neither the dynamite or a ");
  682. printf("blasting cap.\n") ;
  683.                 return ;
  684.             }
  685.             if (Cap->Location != B_have) {
  686. printf("You've got the dynamite but you need a blasing cap.\n") ;
  687.                 return ;
  688.             }
  689.                 if (Dynamite->Location != B_have) {
  690. printf("You've got the blasting cap but you need some dynamite.\n") ;
  691.                 return ;
  692.             }
  693. /* transform the two objects into one */
  694. printf("With some trepidation, you slide the blasting cap into\n");
  695. printf("the dynamite.  What you are now holding is VERY dangerous.\n");
  696.             Cap->Location = B_unmade ; 
  697.             Dynamite->Type = Z_alias ;
  698.             carry_weight -= Cap->Weight ;
  699.             carry_count-- ;
  700.             return ;
  701.         } /* end of the cap insertion block */
  702.     }
  703. printf("I can think of some interesing places to insert this. \n") ;
  704. printf("However I shall not reduce myself to such vulgarity.\n");
  705.     return ;
  706.     
  707. case V_eject:
  708. /* Command "eject clip" ejects clip from rifle no matter what type*/
  709.     if ((ammo_flag == F_normal_clip)&&(clip_flag == F_org_clip)) 
  710.         ammo_flag = F_org_clip ; 
  711. case V_drop:
  712.     if (((ammo_flag == F_org_clip)&&(clip_flag == F_org_clip))|| 
  713.     ((ammo_flag == F_normal_clip)&&(clip_flag == F_normal_clip))) { 
  714.         clip_out(n) ;
  715.         return ;
  716.     }
  717.     break ;
  718.  
  719. } /* end of switch */
  720.  
  721. /* Deal with "drop" when player has no objects */
  722. if (tag[V_all]&&(carry_count == 0)&&(gleep_count == 0)) {
  723.     printf("You dill!  You have nothing to drop!\n") ;
  724.     return ;
  725. }
  726.  
  727. /* deal with "drop in safe ..." errors */
  728. if (tag[V_safe]) {
  729.     /* see if this is the managers office */
  730.     if (n != R_office_mang) {        
  731.         printf("There is no safe here! \n");
  732.         return ;
  733.     }
  734.  
  735.     /* See if the picture and safe are open */
  736.     if ((Picture->Status != S_open) || (Safe->Status != S_open)) {
  737.         printf ("I don't see an open safe to put anything into.\n") ;
  738.         return ;
  739.     }
  740. }
  741.  
  742. /* gleep droping routine */
  743. if (tag[V_gleep]||tag[V_tank]) {
  744.     /* drop gleeps in a normal way */
  745.     if (!tag[V_tank]) {
  746.         if (gleep_count == 0) { 
  747.             printf("You have no gleeps to drop! \n") ;
  748.             return ;
  749.         }
  750.         if ((!tag[V_PLURAL])||(gleep_count == 1)) {
  751.             if (tag[V_safe]) {
  752.                 printf("Gleep put into safe.\n") ;
  753.                 ++gleep_safe ;
  754.                 --gleep_count ;
  755.             }
  756.             else {
  757.                 printf("Gleep dropped. \n") ; 
  758.                 --gleep_count ;
  759.                 ++room[n][M_gleep] ;
  760.             }
  761.         }
  762.         else {
  763.             if (tag[V_safe]) {
  764.                 if (tag[V_NUMBER]) {
  765.                     if (number_word == 0) {
  766.                         printf("Don't be silly.\n") ;
  767.                         return ;
  768.                     }
  769.                     if (number_word > gleep_count) {
  770. printf("I don't have that many gleeps!\n") ;
  771.                         return ;
  772.                     }
  773.                     else {
  774. printf("You put %d gleeps into the safe.\n", number_word) ; 
  775.                         gleep_safe += number_word ;
  776.                         gleep_count -= number_word ;
  777.                     }
  778.                 }
  779.                 else {
  780.                     printf("Gleeps put into safe.\n") ;
  781.                     gleep_safe += gleep_count ;
  782.                     gleep_count = 0 ;
  783.                 }
  784.             }
  785.             else {
  786.                 if (tag[V_NUMBER]) {
  787.                     if (number_word == 0) {
  788.                         printf("Don't be silly.\n") ;
  789.                         return ;
  790.                     }
  791.                     if (number_word > gleep_count) {
  792. printf("I don't have that many gleeps!\n") ;
  793.                         return ;
  794.                     }
  795.                     else {
  796. printf("You drop %d gleeps.\n", number_word) ; 
  797.                     room[n][M_gleep] += number_word ;
  798.                     gleep_count -= number_word ;
  799.                     }
  800.                 }
  801.                 else {
  802.                     printf("Gleeps dropped. \n") ; 
  803.                     room[n][M_gleep] += gleep_count ;
  804.                     gleep_count = 0 ;
  805.                 }
  806.             }
  807.         }
  808.         gleep_drop = TRUE ;
  809.         return ;
  810.     }
  811.  
  812.     /* drop objects(including gleeps) into a gleep tank */
  813.     else {
  814.         sw_found = FALSE ;
  815.         if (n != R_gleep_tank) {
  816.             printf("I don't see a gleep tank here. \n") ;
  817.             return ;
  818.         }
  819.         if (tag[V_gleep]) {
  820.             if (gleep_count <= 0) {
  821. printf("You have no gleeps to put in the tank. \n") ; 
  822.                 return ;
  823.             }
  824.             sw_found = TRUE ;
  825.             if ((!tag[V_PLURAL])||(gleep_count == 1)) {
  826. printf("Your gleep falls into the tank with a \"plonk\".\n") ;
  827.                 ++Tank->Status ;
  828.                 --gleep_count ;
  829.             }
  830.             if (tag[V_PLURAL]) {
  831.                 if (tag[V_NUMBER]) {
  832.                     if (number_word == 0) {
  833.                         printf("Don't be silly.\n") ;
  834.                         return ;
  835.                     }
  836.                     if (number_word > gleep_count) {
  837. printf("I don't have that many gleeps!\n") ;
  838.                         return ;
  839.                     }
  840.                     else {
  841. printf("You drop %d gleeps into the gleep tank.\n", number_word) ;
  842.                         Tank->Status += number_word ;
  843.                         gleep_count -= number_word ;
  844.                     }
  845.                 }
  846.                 else {
  847. printf("Your gleeps fall into the tank causing a splash.\n") ;
  848.                     Tank->Status += gleep_count ;
  849.                     gleep_count = 0 ;
  850.                 }
  851.             }
  852.         } /* end of the tag[V_gleep] block */
  853.  
  854.         /* Drop non-gleeps into the tank */
  855.         /* the "drop all" routine */
  856.         if (tag[V_all]) {
  857.             sw_possess = FALSE ;
  858.             pnt = object ;
  859.             for (i = 0; i < Objcnt; i++) {
  860.                 if ((pnt->Location == B_have)&&
  861.                     ((!tag[V_treasure])||
  862.                     (pnt->Value > 0))) {
  863.                     sw_possess = TRUE ;
  864.                     pnt->Location = B_destroyed; 
  865.                     carry_count-- ;
  866.                 carry_weight -= pnt->Weight ;
  867.                 }
  868.                 pnt++ ;
  869.             }
  870.             if (gleep_count == 0) {
  871.                 if (sw_possess) {
  872. printf("You dump everything into the gleep tank. There is a furious\n");
  873. printf("bubbling as the corrosive fluid of the tank turns the\n");
  874. printf("objects into NOTHING.\n") ;
  875.                 }
  876.                 else 
  877. printf("You've got nothing to throw into the tank.\n") ;
  878.             }
  879.             else {
  880.                 if (sw_possess) {
  881. printf("You fling everything into the gleep tank.  The gleep");
  882.                 if (gleep_count > 1) {
  883. printf("s\nsplash into the tank and settle to the bottom of the\n") ;
  884.                 }
  885.                 else {
  886. printf("\nplonks into the tank and settles to the bottom of the\n") ;
  887.                 }
  888. printf("tank.  However the other objects begin to dissolve the\n");
  889. printf("moment the tank's fluid touches them.  Time passes and\n");
  890. printf("the objects dissolve into NOTHING.\n") ;
  891.                 }
  892.                 /* you possess no non-gleeps */
  893.                 else {
  894.                 if (gleep_count == 1) 
  895. printf("Your gleep falls into the tank with a \"plonk\".\n") ;
  896.                 else
  897. printf("Your gleeps fall into the tank causing a splash.\n") ;
  898.                 }
  899.             Tank->Status += gleep_count ;
  900.             gleep_count = 0 ;
  901.             }
  902.             return ;
  903.         } /* end of the "drop all" if block */
  904.  
  905.         /* Individual non-gleeps are dropped into the tank */
  906.  
  907.         /* see if your are holding the object(s) */
  908.         pnt = object ;
  909.         for (i = 0; i < Objcnt; i++) {
  910.              if (tag[pnt->ID] && (pnt->ID != V_tank)) {
  911.                 if (pnt->Location == B_have) {
  912. printf ("You fling the %s into the gleep tank.  As soon as it\n",
  913.     vocab[pnt->ID - 1]);
  914. printf ("touched the tank's fluid there was a furious effervescence\n");
  915. printf ("as it began to dissolve.  With the passage of time, the\n") ;
  916. printf ("fluid stills and there is NOTHING left.\n") ;
  917.                     carry_count-- ;
  918.                     carry_weight -= pnt->Weight ;
  919.                     pnt->Location = B_destroyed; 
  920.                 }
  921.                 else {
  922. printf("You don't have a %s to toss into the gleep tank.\n",
  923.     vocab[pnt->ID - 1]);
  924.                 }
  925.                 return ;
  926.             }
  927.             pnt++ ;
  928.         } /* object scan "for" loop */
  929.  
  930.         /* deal with garbage object to drop */
  931. if (!sw_found) printf("I don't understand what you want me to drop.\n") ;
  932.         return ;
  933.     }
  934. }
  935.  
  936. sw_done = FALSE ;
  937.  
  938. /* the "drop all" routine */
  939. if (tag[V_all]) {
  940.  
  941.     /* Deal with throwing stuff into water */
  942.     if(tag[V_stream]) {
  943.         if (n == R_stream) {
  944. printf("You fling everything into the stream.\n");
  945.             destroy_all() ;
  946.             return ;
  947.         }
  948.         else
  949. printf("I see no stream to toss stuff into.\n") ;
  950.         return ;
  951.     }
  952.     if(tag[V_billabong]) {
  953.         if ((n == R_stream)||(n == R_slime)||
  954.             (n == R_billabong)) { 
  955. printf("You fling everything into the billabong.\n");
  956.             destroy_all() ;
  957.             return ;
  958.         }
  959.         else
  960. printf("I see no billabong to toss stuff into.\n") ;
  961.         return ;
  962.     }
  963.     if(tag[V_river]) {
  964.         if ((n == R_dike)||(n == R_river_edge)||
  965.             (n == R_river_exit)) {
  966. printf("You fling everything into the river.\n");
  967.             destroy_all() ;
  968.             return ;
  969.         }
  970.         else
  971. printf("I see no river to toss stuff into.\n") ;
  972.         return ;
  973.     }
  974.  
  975.     if (!tag[V_safe]) {
  976. /* normal drop */
  977. if (room[n][M_rm_type] != T_looping) {
  978.     /* normal room */
  979.     pnt = object ;
  980.     for (i = 0; i < Objcnt; i++) {
  981.         if ((pnt->Location == B_have)&&
  982.             ((!tag[V_treasure]) || (pnt->Value > 0))) {
  983.  
  984.         sw_done = TRUE ;
  985.  
  986.         /* see if the blasting cap was hard dropped */
  987.         if ((pnt->ID == V_cap)&&(verb != V_slow_drop)) {
  988.             cap_drop() ;
  989.             return ;
  990.         }
  991.  
  992. /* see if the dynamite with blasting cap was hard dropped */
  993.         if ((pnt->ID == V_dynamite)&&(Dynamite->Type == Z_alias)
  994.             &&(verb != V_slow_drop)) dynamite_drop() ;
  995.         ++room[n][M_obj_cnt] ;
  996.         carry_count-- ;
  997.         carry_weight -= pnt->Weight ;
  998.         pnt->Location = n; 
  999. /* set valuable switch if valuable object dropped in Ned's area */
  1000.         if (pnt->Value > 0) {
  1001.             for (k = 22; k <= 41; k++) 
  1002.                 if (k == n) sw_valuable = TRUE;
  1003.             for (k = 144; k <= 146; k++) 
  1004.                  if (k == n) sw_valuable = TRUE;
  1005.         }
  1006.     }
  1007.     pnt++ ;
  1008. }
  1009.             /* drop all gleeps */
  1010.             if ((gleep_count > 0) &&
  1011.                     (!tag[V_treasure])) {
  1012.                 room[n][M_gleep] += gleep_count ;
  1013.                 gleep_count = 0 ;
  1014.                 sw_done = TRUE ;
  1015.                 gleep_drop = TRUE ;
  1016.             }
  1017.  
  1018.             if (sw_done) {
  1019.                 printf ("Done\n");
  1020.                 objlooker(n) ;
  1021.                 gleeper(n) ; 
  1022.             } 
  1023.             else printf("Don't have it to drop.\n") ;
  1024.             return ;
  1025.         }
  1026.         /* object destroyer room */
  1027.         else {
  1028.         /* Code assumes that player has something to drop */
  1029. printf ("You dropped everything you had in a heap, which \n");
  1030. printf ("promptly vaporized into a bright blue flash followed \n");
  1031. printf ("by a low \"BOOM\". \n") ; 
  1032. printf ("       --- You've blown it Bozo!! ---\n") ;
  1033.             destroy_all() ;
  1034.             return ;
  1035.         }
  1036.     }
  1037.     /* "drop all into the safe" routine */
  1038.     else {
  1039.         pnt = object ;
  1040.         for (i = 0; i < Objcnt; i++) {
  1041.             if ((pnt->Location == B_have) &&
  1042.                 ((!tag[V_treasure])||
  1043.                 (pnt->Value > 0))) {
  1044.                 pnt->Location = B_in_safe ;    
  1045.                 carry_count-- ;
  1046.                 carry_weight -= pnt->Weight ;
  1047.                 sw_done = TRUE ;
  1048.             }
  1049.             pnt++ ;
  1050.         }
  1051.         if (!tag[V_treasure]) {
  1052.             gleep_safe += gleep_count ;
  1053.             gleep_count = 0 ;
  1054.             sw_done = TRUE ;
  1055.         }
  1056.         if (sw_done) printf ("Done \n");
  1057.         else printf("You don't have it to put in the safe!\n") ;
  1058.         return ;
  1059.     }
  1060. }
  1061.  
  1062. /* see if your are holding the object(s) */
  1063. for (i = 0; i < Objcnt; i++) {
  1064.     if (i == 0) pnt = object ;
  1065.     else pnt++ ;
  1066.     sw_object = FALSE ;
  1067.     if (tag[pnt->ID]) {
  1068.         sw_object = TRUE ;
  1069.          if (pnt->Location == B_have) {
  1070.             /* Safe storage routine */
  1071.             if (tag[V_safe]) {
  1072.                 pnt->Location = B_in_safe ;    
  1073. printf ("The %s is now inside the safe. \n", 
  1074.     vocab[pnt->ID - 1]);
  1075.                 sw_done = TRUE ;
  1076.                 carry_count-- ;
  1077.                 carry_weight -= pnt->Weight ;
  1078.                 continue ;
  1079.             }
  1080.  
  1081.             /* Single 'drop' routine */
  1082.             if (tag[V_river]||tag[V_billabong]||
  1083.                 tag[V_stream]) {
  1084.         /* The object is to be dropped in water */
  1085.                 if(tag[V_stream]) {
  1086.                     if (n == R_stream) {
  1087. printf("You fling the %s into the stream.\n", 
  1088.     vocab[pnt->ID - 1]);
  1089.                     carry_count-- ;
  1090.                 carry_weight -= pnt->Weight ;
  1091.                     pnt->Location = B_destroyed; 
  1092.                     return ;
  1093.                     }
  1094.                     else
  1095. printf("I see no stream to toss it into.\n") ;
  1096.                     return ;
  1097.                 }
  1098.             if(tag[V_billabong]) {
  1099.                 if ((n == R_stream)||
  1100.                 (n == R_slime)||(n == R_billabong)) { 
  1101. printf("You fling the %s into the billabong.\n",
  1102.     vocab[pnt->ID - 1]);
  1103.                     carry_count-- ;
  1104.                 carry_weight -= pnt->Weight ;
  1105.                     pnt->Location = B_destroyed; 
  1106.                     return ;
  1107.                 }
  1108.                 else
  1109. printf("I see no billabong to toss it into.\n") ;
  1110.                 return ;
  1111.             }
  1112.             if(tag[V_river]) {
  1113.                 if ((n == R_dike)||(n == R_river_edge)||
  1114.                     (n == R_river_exit)) {
  1115. printf("You fling the %s into the river.\n", 
  1116.     vocab[pnt->ID - 1]);
  1117.                     carry_count-- ;
  1118.                 carry_weight -= pnt->Weight ;
  1119.                     pnt->Location = B_destroyed; 
  1120.                     return ;
  1121.                 }
  1122.                 else
  1123. printf("I see no river to toss it into.\n") ;
  1124.                 return ;
  1125.             }
  1126.         }
  1127.         /* Normal Drop */
  1128.         else if (room[n][M_rm_type] != T_looping) {
  1129.             if ((pnt->ID == V_cap)&&(verb != V_slow_drop)) {
  1130.                 cap_drop() ;
  1131.                 return ;
  1132.             }
  1133.             if ((pnt->ID == V_dynamite)&&(verb != V_slow_drop)&&
  1134.         (Dynamite->Type == Z_alias)) dynamite_drop();
  1135.  
  1136. /* If the he rifle is dropped.  See if it kills the player */
  1137. if (pnt->ID == V_rifle) {
  1138.     if ((clip_flag != F_no_clip) && 
  1139. (Rifle->Status > 0)) switch(rifle_flag) {
  1140.     case F_safety:
  1141.         break ;
  1142.             
  1143.     case F_single:
  1144.         printf("\nBam!\n") ;
  1145.         dropped_gun() ;
  1146.  
  1147.     case F_triple:
  1148.         printf("\n") ;
  1149.         if (Rifle->Status >= 3) {
  1150.             printf("Bam! Bam! Bam! \n\n") ;
  1151.         }
  1152.         else {
  1153.         for (k = 1; k <= Rifle->Status; k++) 
  1154.             printf("Bam! ") ;
  1155.         }
  1156.         dropped_gun() ;
  1157.  
  1158.     case F_auto:
  1159.         printf("\n") ;
  1160.         if (Rifle->Status >= 30) {
  1161.             for (k = 1; k <= 3; k++) 
  1162. printf("Bam! Bam! Bam! Bam! Bam! Bam! Bam! Bam! Bam! Bam! \n") ;
  1163.         }
  1164.         else {
  1165.             i_10 = Rifle->Status / 10 ;
  1166.         i_fract = Rifle->Status - (i_10 * 10) ;
  1167.             for (k = 1; k <= i_10; k++) 
  1168. printf("Bam! Bam! Bam! Bam! Bam! Bam! Bam! Bam! Bam! Bam! \n") ;
  1169.             for (k = 1; k <= i_fract; k++) 
  1170.                 printf("Bam! ") ;
  1171.         }
  1172.         dropped_gun() ;
  1173.     } /* end of the switch block */
  1174. } /* end of "drop rifle" block */
  1175.  
  1176.             carry_count-- ;
  1177.             carry_weight -= pnt->Weight ;
  1178.             ++room[n][M_obj_cnt] ;
  1179.             pnt->Location = n; 
  1180.             sw_done = TRUE ;
  1181. /* set valuable switch if valuable object dropped in Ned's area */
  1182.             if (pnt->Value > 0) {
  1183.                 for (k = 22; k <= 41; k++) 
  1184.                     if (k == n) sw_valuable = TRUE ;
  1185.                 for (k = 144; k <= 146; k++) 
  1186.                     if (k == n) sw_valuable = TRUE ;
  1187.             }
  1188.             continue ;
  1189.         }
  1190.         else {
  1191. printf ("As the %s left your possession there was a bright \n",
  1192.     vocab[pnt->ID - 1]);
  1193. printf ("blue flash, followed by a low \"BOOM\" as it vaporized \n");
  1194. printf ("into nonexistence. \n");
  1195.             carry_count-- ;
  1196.             carry_weight -= pnt->Weight ;
  1197.             pnt->Location = B_destroyed; 
  1198.             return ;
  1199.         }
  1200.         }
  1201.          if (pnt->Location == B_unmade) continue ;
  1202.     } /* end of the object requested block */
  1203.     if ((!sw_done)&&sw_object) {
  1204. printf("You do not possess a %s.\n", vocab[pnt->ID - 1]);
  1205.         return ;
  1206.     }
  1207. } /* end of the object scan loop */
  1208. if (sw_done) {
  1209.     printf ("Done \n");
  1210.     objlooker(n) ;
  1211.     gleeper(n) ; 
  1212. } 
  1213. else 
  1214. printf("I don't understand what it is I'm supposed to drop.\n") ;
  1215.  
  1216. return ;
  1217.  
  1218.  
  1219. } /* --- end of the "dropper" subroutine --- */
  1220.  
  1221. #if (PROTOTYPE)
  1222. void cap_drop(void)
  1223. #else
  1224. cap_drop()
  1225. #endif
  1226. /*********************************************************/
  1227. /*                                                       */
  1228. /*         --- Blasing Cap Dropping Subroutine ---       */
  1229. /*                                                       */
  1230. /*      Program by Gary A. Allen, Jr.  6 December 1992   */
  1231. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  1232. /*                                                       */
  1233. /*********************************************************/
  1234. {
  1235. printf("Bang!! The blasting cap you were carrying detonated when\n") ;
  1236. printf("it hit the ground.  Fortunately no damage was caused.\n") ;  
  1237. Cap->Location = B_destroyed; 
  1238. carry_count-- ;
  1239. carry_weight -= Cap->Weight ;
  1240.  
  1241. } /* --- end of the "cap_drop" subroutine --- */
  1242.  
  1243. #if (PROTOTYPE)
  1244. void dynamite_drop(void)
  1245. #else
  1246. dynamite_drop()
  1247. #endif
  1248. /*********************************************************/
  1249. /*                                                       */
  1250. /*           --- Dynamite Dropping Subroutine ---        */
  1251. /*                                                       */
  1252. /*      Program by Gary A. Allen, Jr.  6 December 1992   */
  1253. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  1254. /*                                                       */
  1255. /*********************************************************/
  1256. {
  1257. #if (PROTOTYPE)
  1258. void ender(int), boom(void) ;
  1259. #endif
  1260.  
  1261. boom() ;
  1262. printf("Dropping a stick of dynamite with a blasting cap in it\n");
  1263. printf("ranks high as one of the dumbest things a person can do.\n") ;
  1264. printf("Needless to say you were blown to bits. Next time drop\n") ;
  1265. printf("the dynamite slowly or gently.\n") ;
  1266. ender(F_died) ;
  1267.  
  1268. } /* --- end of the "dynamite_drop" subroutine --- */
  1269.  
  1270. #if (PROTOTYPE)
  1271. void destroy_all(void)
  1272. #else
  1273. destroy_all()
  1274. #endif
  1275. /*********************************************************/
  1276. /*                                                       */
  1277. /*        --- Destroy Everything Held Subroutine ---     */
  1278. /*                                                       */
  1279. /*      Program by Gary A. Allen, Jr.  6 December 1992   */
  1280. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  1281. /*                                                       */
  1282. /*********************************************************/
  1283. {
  1284. register int i ;
  1285. OBJECT_STRUCT *pnt ;
  1286.  
  1287. gleep_count = 0 ;
  1288. carry_count = 0 ;
  1289. carry_weight = 0 ;
  1290. pnt = object ;
  1291. for (i = 0; i < Objcnt; i++) {
  1292.     if (pnt->Location == B_have)  pnt->Location = B_destroyed; 
  1293.     pnt++ ;
  1294. }
  1295. } /* --- end of the "destroy_all" subroutine --- */
  1296.  
  1297. #if (PROTOTYPE)
  1298. void dropped_gun(void)
  1299. #else
  1300. dropped_gun()
  1301. #endif
  1302. /*********************************************************/
  1303. /*                                                       */
  1304. /*     --- Player Suicides by Dropping Armed Rifle ---   */
  1305. /*                                                       */
  1306. /*      Program by Gary A. Allen, Jr.  31 December 1992  */
  1307. /*        (c) Copyright 1992 by Gary A. Allen, Jr.       */
  1308. /*                                                       */
  1309. /*********************************************************/
  1310. {
  1311. #if (PROTOTYPE)
  1312. void ender(int) ;
  1313. #endif
  1314.  
  1315. printf("\n") ;
  1316. printf("Dropping a loaded and armed automatic rifle is a stupid way\n");
  1317. if ((Rifle->Status == 1) || (rifle_flag == F_single)) {
  1318. printf("to commit suicide.  Needless to say you were hit by the\n") ;
  1319. printf("bullet after the rifle went off.\n") ;
  1320. }
  1321. else {
  1322. printf("to commit suicide.  The bullets shot from the rifle fly\n") ;
  1323. printf("around.  One of them bounces back and hits you!\n") ;
  1324. }
  1325. ender(F_died) ;
  1326. } /* --- end of the "dropped_gun" subroutine --- */
  1327.